home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1995 June / MacFormat 25.iso / Shareware City / Developers / OutOfPhase1.1 Source / OutOfPhase Folder / AlgoSampWindow.c < prev    next >
Text File  |  1994-12-28  |  51KB  |  1,684 lines
  1. /* AlgoSampWindow.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "AlgoSampWindow.h"
  31. #include "MainWindowStuff.h"
  32. #include "AlgoSampObject.h"
  33. #include "TextEdit.h"
  34. #include "IconButton.h"
  35. #include "WindowDispatcher.h"
  36. #include "Memory.h"
  37. #include "Alert.h"
  38. #include "Numbers.h"
  39. #include "GrowIcon.h"
  40. #include "DataMunging.h"
  41. #include "Main.h"
  42. #include "AlgoSampList.h"
  43. #include "EditImages.h"
  44. #include "FindDialog.h"
  45. #include "GlobalWindowMenuList.h"
  46.  
  47.  
  48. #define WINSIZEX (490)
  49. #define WINSIZEY (300)
  50. #define TITLEINDENT (8)
  51.  
  52. #define NAMEEDITX (80)
  53. #define NAMEEDITY (1)
  54. #define NAMEEDITWIDTH (80)
  55. #define NAMEEDITHEIGHT (19)
  56.  
  57. #define SAMPLINGRATEEDITX (80)
  58. #define SAMPLINGRATEEDITY (21)
  59. #define SAMPLINGRATEEDITWIDTH (80)
  60. #define SAMPLINGRATEEDITHEIGHT (19)
  61.  
  62. #define ORIGINEDITX (240)
  63. #define ORIGINEDITY (1)
  64. #define ORIGINEDITWIDTH (80)
  65. #define ORIGINEDITHEIGHT (19)
  66.  
  67. #define BASEFREQEDITX (240)
  68. #define BASEFREQEDITY (21)
  69. #define BASEFREQEDITWIDTH (80)
  70. #define BASEFREQEDITHEIGHT (19)
  71.  
  72. #define LOOPSTARTEDIT1X (400)
  73. #define LOOPSTARTEDIT1Y (1)
  74. #define LOOPSTARTEDIT1WIDTH (80)
  75. #define LOOPSTARTEDIT1HEIGHT (19)
  76.  
  77. #define LOOPSTARTEDIT2X (240)
  78. #define LOOPSTARTEDIT2Y (42)
  79. #define LOOPSTARTEDIT2WIDTH (80)
  80. #define LOOPSTARTEDIT2HEIGHT (19)
  81.  
  82. #define LOOPSTARTEDIT3X (400)
  83. #define LOOPSTARTEDIT3Y (42)
  84. #define LOOPSTARTEDIT3WIDTH (80)
  85. #define LOOPSTARTEDIT3HEIGHT (19)
  86.  
  87. #define LOOPENDEDIT1X (400)
  88. #define LOOPENDEDIT1Y (21)
  89. #define LOOPENDEDIT1WIDTH (80)
  90. #define LOOPENDEDIT1HEIGHT (19)
  91.  
  92. #define LOOPENDEDIT2X (240)
  93. #define LOOPENDEDIT2Y (63)
  94. #define LOOPENDEDIT2WIDTH (80)
  95. #define LOOPENDEDIT2HEIGHT (19)
  96.  
  97. #define LOOPENDEDIT3X (400)
  98. #define LOOPENDEDIT3Y (63)
  99. #define LOOPENDEDIT3WIDTH (80)
  100. #define LOOPENDEDIT3HEIGHT (19)
  101.  
  102. #define BITS8X (10)
  103. #define BITS8Y (45)
  104. #define BITS8WIDTH (32)
  105. #define BITS8HEIGHT (32)
  106.  
  107. #define BITS16X (BITS8X + BITS8WIDTH + 1)
  108. #define BITS16Y (BITS8Y)
  109. #define BITS16WIDTH (BITS8WIDTH)
  110. #define BITS16HEIGHT (BITS8HEIGHT)
  111.  
  112. #define MONOX (BITS16X + BITS16WIDTH + 10)
  113. #define MONOY (BITS16Y)
  114. #define MONOWIDTH (BITS16WIDTH)
  115. #define MONOHEIGHT (BITS16HEIGHT)
  116.  
  117. #define STEREOX (MONOX + MONOWIDTH + 1)
  118. #define STEREOY (MONOY)
  119. #define STEREOWIDTH (MONOWIDTH)
  120. #define STEREOHEIGHT (MONOHEIGHT)
  121.  
  122. #define SAMPLENAMEX (3)
  123. #define SAMPLENAMEY (4)
  124.  
  125. #define SAMPLERATEX (3)
  126. #define SAMPLERATEY (23)
  127.  
  128. #define ORIGINX (170)
  129. #define ORIGINY (4)
  130.  
  131. #define BASEFREQX (170)
  132. #define BASEFREQY (23)
  133.  
  134. #define LOOPSTART1X (330)
  135. #define LOOPSTART1Y (4)
  136.  
  137. #define LOOPSTART2X (170)
  138. #define LOOPSTART2Y (44)
  139.  
  140. #define LOOPSTART3X (330)
  141. #define LOOPSTART3Y (44)
  142.  
  143. #define LOOPEND1X (330)
  144. #define LOOPEND1Y (23)
  145.  
  146. #define LOOPEND2X (170)
  147. #define LOOPEND2Y (65)
  148.  
  149. #define LOOPEND3X (330)
  150. #define LOOPEND3Y (65)
  151.  
  152. #define BODYX (-1)
  153. #define BODYY (STEREOY + STEREOHEIGHT + 4)
  154. #define BODYWIDTH(Width) ((Width) + 2)
  155. #define BODYHEIGHT(Height) ((Height) - BODYY + 1)
  156.  
  157.  
  158. struct AlgoSampWindowRec
  159.     {
  160.         MainWindowRec*            MainWindow;
  161.         AlgoSampObjectRec*    AlgoSampObject;
  162.         AlgoSampListRec*        AlgoSampList;
  163.  
  164.         WinType*                        ScreenID;
  165.         TextEditRec*                NameEdit;
  166.         TextEditRec*                BodyEdit;
  167.         TextEditRec*                SamplingRateEdit;
  168.         TextEditRec*                OriginEdit;
  169.         TextEditRec*                NaturalFrequencyEdit;
  170.         TextEditRec*                LoopStartEdit1;
  171.         TextEditRec*                LoopStartEdit2;
  172.         TextEditRec*                LoopStartEdit3;
  173.         TextEditRec*                LoopEndEdit1;
  174.         TextEditRec*                LoopEndEdit2;
  175.         TextEditRec*                LoopEndEdit3;
  176.         TextEditRec*                ActiveTextEdit;
  177.         IconButtonRec*            MonoButton;
  178.         IconButtonRec*            StereoButton;
  179.         MyBoolean                        ChannelsButtonChanged;
  180.         IconButtonRec*            Bits8Button;
  181.         IconButtonRec*            Bits16Button;
  182.         MyBoolean                        BitsButtonChanged;
  183.         GenericWindowRec*        MyGenericWindow; /* how the window event dispatcher knows us */
  184.         MenuItemType*                MyMenuItem;
  185.     };
  186.  
  187.  
  188. /* allocate a new algorithmic sample window */
  189. AlgoSampWindowRec*    NewAlgoSampWindow(struct MainWindowRec* MainWindow,
  190.                                             struct AlgoSampObjectRec* AlgoSampObject,
  191.                                             struct AlgoSampListRec* AlgoSampList, OrdType WinX, OrdType WinY,
  192.                                             OrdType WinWidth, OrdType WinHeight)
  193.     {
  194.         AlgoSampWindowRec*    Window;
  195.         OrdType                            FontHeight;
  196.         char*                                StringTemp;
  197.  
  198.         /* deal with window placement */
  199.         if ((WinWidth < 100) || (WinHeight < 100) || ((eOptionKey & CheckModifiers()) != 0))
  200.             {
  201.                 WinX = 20 + WindowOtherEdgeWidths(eDocumentWindow);
  202.                 WinY = 20 + WindowTitleBarHeight(eDocumentWindow);
  203.                 WinWidth = WINSIZEX;
  204.                 WinHeight = WINSIZEY;
  205.             }
  206.         MakeWindowFitOnScreen(&WinX,&WinY,&WinWidth,&WinHeight);
  207.  
  208.         Window = (AlgoSampWindowRec*)AllocPtrCanFail(
  209.             sizeof(AlgoSampWindowRec),"AlgoSampWindowRec");
  210.         if (Window == NIL)
  211.             {
  212.              FailurePoint1:
  213.                 AlertHalt("There is not enough memory available to display the algorithmic "
  214.                     "sample editor.",NIL);
  215.                 return NIL;
  216.             }
  217.         Window->MainWindow = MainWindow;
  218.         Window->AlgoSampObject = AlgoSampObject;
  219.         Window->AlgoSampList = AlgoSampList;
  220.         Window->ChannelsButtonChanged = False;
  221.         Window->BitsButtonChanged = False;
  222.  
  223.         Window->ScreenID = MakeNewWindow(eDocumentWindow,eWindowClosable,
  224.             eWindowZoomable,eWindowResizable,WinX,WinY,WinWidth,WinHeight,
  225.             (void (*)(void*))&AlgoSampWindowUpdator,Window);
  226.         if (Window->ScreenID == 0)
  227.             {
  228.              FailurePoint2:
  229.                 ReleasePtr((char*)Window);
  230.                 goto FailurePoint1;
  231.             }
  232.         FontHeight = GetFontHeight(GetScreenFont(),9);
  233.  
  234.         /* create name edit */
  235.         Window->NameEdit = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  236.             GetScreenFont(),9,NAMEEDITX,NAMEEDITY,NAMEEDITWIDTH,NAMEEDITHEIGHT);
  237.         if (Window->NameEdit == NIL)
  238.             {
  239.              FailurePoint3:
  240.                 KillWindow(Window->ScreenID);
  241.                 goto FailurePoint2;
  242.             }
  243.         /* install new text in name edit */
  244.         StringTemp = AlgoSampObjectGetNameCopy(AlgoSampObject);
  245.         if (StringTemp == NIL)
  246.             {
  247.              FailurePoint4:
  248.                 DisposeTextEdit(Window->NameEdit);
  249.                 goto FailurePoint3;
  250.             }
  251.         TextEditNewRawData(Window->NameEdit,StringTemp,"\x0a");
  252.         ReleasePtr(StringTemp);
  253.         TextEditHasBeenSaved(Window->NameEdit);
  254.  
  255.         /* create sampling rate edit */
  256.         Window->SamplingRateEdit = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  257.             GetScreenFont(),9,SAMPLINGRATEEDITX,SAMPLINGRATEEDITY,
  258.             SAMPLINGRATEEDITWIDTH,SAMPLINGRATEEDITHEIGHT);
  259.         if (Window->SamplingRateEdit == NIL)
  260.             {
  261.              FailurePoint5:
  262.                 goto FailurePoint4;
  263.             }
  264.         StringTemp = IntegerToString(AlgoSampObjectGetSamplingRate(AlgoSampObject));
  265.         if (StringTemp == NIL)
  266.             {
  267.              FailurePoint6:
  268.                 DisposeTextEdit(Window->SamplingRateEdit);
  269.                 goto FailurePoint5;
  270.             }
  271.         TextEditNewRawData(Window->SamplingRateEdit,StringTemp,"\x0a");
  272.         ReleasePtr(StringTemp);
  273.         TextEditHasBeenSaved(Window->SamplingRateEdit);
  274.  
  275.         /* create origin edit */
  276.         Window->OriginEdit = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  277.             GetScreenFont(),9,ORIGINEDITX,ORIGINEDITY,ORIGINEDITWIDTH,ORIGINEDITHEIGHT);
  278.         if (Window->OriginEdit == NIL)
  279.             {
  280.              FailurePoint7:
  281.                 goto FailurePoint6;
  282.             }
  283.         StringTemp = IntegerToString(AlgoSampObjectGetOrigin(AlgoSampObject));
  284.         if (StringTemp == NIL)
  285.             {
  286.              FailurePoint8:
  287.                 DisposeTextEdit(Window->OriginEdit);
  288.                 goto FailurePoint7;
  289.             }
  290.         TextEditNewRawData(Window->OriginEdit,StringTemp,"\x0a");
  291.         ReleasePtr(StringTemp);
  292.         TextEditHasBeenSaved(Window->OriginEdit);
  293.  
  294.         /* create base frequency edit */
  295.         Window->NaturalFrequencyEdit = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  296.             GetScreenFont(),9,BASEFREQEDITX,BASEFREQEDITY,BASEFREQEDITWIDTH,
  297.             BASEFREQEDITHEIGHT);
  298.         if (Window->NaturalFrequencyEdit == NIL)
  299.             {
  300.              FailurePoint9:
  301.                 goto FailurePoint8;
  302.             }
  303.         StringTemp = LongDoubleToString(AlgoSampObjectGetNaturalFrequency(AlgoSampObject),
  304.             13,1e-4,1e6);
  305.         if (StringTemp == NIL)
  306.             {
  307.              FailurePoint10:
  308.                 DisposeTextEdit(Window->NaturalFrequencyEdit);
  309.                 goto FailurePoint9;
  310.             }
  311.         TextEditNewRawData(Window->NaturalFrequencyEdit,StringTemp,"\x0a");
  312.         ReleasePtr(StringTemp);
  313.         TextEditHasBeenSaved(Window->NaturalFrequencyEdit);
  314.  
  315.         /* create loop start edit */
  316.         Window->LoopStartEdit1 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  317.             GetScreenFont(),9,LOOPSTARTEDIT1X,LOOPSTARTEDIT1Y,LOOPSTARTEDIT1WIDTH,
  318.             LOOPSTARTEDIT1HEIGHT);
  319.         if (Window->LoopStartEdit1 == NIL)
  320.             {
  321.              FailurePoint11:
  322.                 goto FailurePoint10;
  323.             }
  324.         StringTemp = IntegerToString(AlgoSampObjectGetLoopStart1(AlgoSampObject));
  325.         if (StringTemp == NIL)
  326.             {
  327.              FailurePoint12:
  328.                 DisposeTextEdit(Window->LoopStartEdit1);
  329.                 goto FailurePoint11;
  330.             }
  331.         TextEditNewRawData(Window->LoopStartEdit1,StringTemp,"\x0a");
  332.         ReleasePtr(StringTemp);
  333.         TextEditHasBeenSaved(Window->LoopStartEdit1);
  334.  
  335.         Window->LoopStartEdit2 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  336.             GetScreenFont(),9,LOOPSTARTEDIT2X,LOOPSTARTEDIT2Y,LOOPSTARTEDIT2WIDTH,
  337.             LOOPSTARTEDIT2HEIGHT);
  338.         if (Window->LoopStartEdit2 == NIL)
  339.             {
  340.              FailurePoint13:
  341.                 goto FailurePoint12;
  342.             }
  343.         StringTemp = IntegerToString(AlgoSampObjectGetLoopStart2(AlgoSampObject));
  344.         if (StringTemp == NIL)
  345.             {
  346.              FailurePoint14:
  347.                 DisposeTextEdit(Window->LoopStartEdit2);
  348.                 goto FailurePoint13;
  349.             }
  350.         TextEditNewRawData(Window->LoopStartEdit2,StringTemp,"\x0a");
  351.         ReleasePtr(StringTemp);
  352.         TextEditHasBeenSaved(Window->LoopStartEdit2);
  353.  
  354.         Window->LoopStartEdit3 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  355.             GetScreenFont(),9,LOOPSTARTEDIT3X,LOOPSTARTEDIT3Y,LOOPSTARTEDIT3WIDTH,
  356.             LOOPSTARTEDIT3HEIGHT);
  357.         if (Window->LoopStartEdit3 == NIL)
  358.             {
  359.              FailurePoint15:
  360.                 goto FailurePoint14;
  361.             }
  362.         StringTemp = IntegerToString(AlgoSampObjectGetLoopStart3(AlgoSampObject));
  363.         if (StringTemp == NIL)
  364.             {
  365.              FailurePoint16:
  366.                 DisposeTextEdit(Window->LoopStartEdit3);
  367.                 goto FailurePoint15;
  368.             }
  369.         TextEditNewRawData(Window->LoopStartEdit3,StringTemp,"\x0a");
  370.         ReleasePtr(StringTemp);
  371.         TextEditHasBeenSaved(Window->LoopStartEdit3);
  372.  
  373.         /* create loop end edit */
  374.         Window->LoopEndEdit1 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  375.             GetScreenFont(),9,LOOPENDEDIT1X,LOOPENDEDIT1Y,LOOPENDEDIT1WIDTH,LOOPENDEDIT1HEIGHT);
  376.         if (Window->LoopEndEdit1 == NIL)
  377.             {
  378.              FailurePoint17:
  379.                 goto FailurePoint16;
  380.             }
  381.         StringTemp = IntegerToString(AlgoSampObjectGetLoopEnd1(AlgoSampObject));
  382.         if (StringTemp == NIL)
  383.             {
  384.              FailurePoint18:
  385.                 DisposeTextEdit(Window->LoopEndEdit1);
  386.                 goto FailurePoint17;
  387.             }
  388.         TextEditNewRawData(Window->LoopEndEdit1,StringTemp,"\x0a");
  389.         ReleasePtr(StringTemp);
  390.         TextEditHasBeenSaved(Window->LoopEndEdit1);
  391.  
  392.         Window->LoopEndEdit2 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  393.             GetScreenFont(),9,LOOPENDEDIT2X,LOOPENDEDIT2Y,LOOPENDEDIT2WIDTH,LOOPENDEDIT2HEIGHT);
  394.         if (Window->LoopEndEdit2 == NIL)
  395.             {
  396.              FailurePoint19:
  397.                 goto FailurePoint18;
  398.             }
  399.         StringTemp = IntegerToString(AlgoSampObjectGetLoopEnd2(AlgoSampObject));
  400.         if (StringTemp == NIL)
  401.             {
  402.              FailurePoint20:
  403.                 DisposeTextEdit(Window->LoopEndEdit2);
  404.                 goto FailurePoint19;
  405.             }
  406.         TextEditNewRawData(Window->LoopEndEdit2,StringTemp,"\x0a");
  407.         ReleasePtr(StringTemp);
  408.         TextEditHasBeenSaved(Window->LoopEndEdit2);
  409.  
  410.         Window->LoopEndEdit3 = NewTextEdit(Window->ScreenID,eTENoScrollBars,
  411.             GetScreenFont(),9,LOOPENDEDIT3X,LOOPENDEDIT3Y,LOOPENDEDIT3WIDTH,LOOPENDEDIT3HEIGHT);
  412.         if (Window->LoopEndEdit3 == NIL)
  413.             {
  414.              FailurePoint21:
  415.                 goto FailurePoint19;
  416.             }
  417.         StringTemp = IntegerToString(AlgoSampObjectGetLoopEnd3(AlgoSampObject));
  418.         if (StringTemp == NIL)
  419.             {
  420.              FailurePoint22:
  421.                 DisposeTextEdit(Window->LoopEndEdit3);
  422.                 goto FailurePoint20;
  423.             }
  424.         TextEditNewRawData(Window->LoopEndEdit3,StringTemp,"\x0a");
  425.         ReleasePtr(StringTemp);
  426.         TextEditHasBeenSaved(Window->LoopEndEdit3);
  427.  
  428.         Window->MonoButton = NewIconButtonPreparedBitmaps(Window->ScreenID,MONOX,MONOY,
  429.             MONOWIDTH,MONOHEIGHT,MonoUnselected,MonoMouseDown,MonoSelected,MonoSelected,
  430.             eIconRadioMode);
  431.         if (Window->MonoButton == NIL)
  432.             {
  433.              FailurePoint23:
  434.                 goto FailurePoint22;
  435.             }
  436.  
  437.         Window->StereoButton = NewIconButtonPreparedBitmaps(Window->ScreenID,STEREOX,STEREOY,
  438.             STEREOWIDTH,STEREOHEIGHT,StereoUnselected,StereoMouseDown,StereoSelected,
  439.             StereoSelected,eIconRadioMode);
  440.         if (Window->StereoButton == NIL)
  441.             {
  442.              FailurePoint24:
  443.                 DisposeIconButton(Window->MonoButton);
  444.                 goto FailurePoint23;
  445.             }
  446.         switch (AlgoSampObjectGetNumChannels(AlgoSampObject))
  447.             {
  448.                 case eSampleStereo:
  449.                     SetIconButtonState(Window->StereoButton,True);
  450.                     break;
  451.                 case eSampleMono:
  452.                     SetIconButtonState(Window->MonoButton,True);
  453.                     break;
  454.                 default:
  455.                     EXECUTE(PRERR(ForceAbort,"NewAlgoSampWindow:  bad num channels value"));
  456.                     break;
  457.             }
  458.  
  459.         Window->Bits8Button = NewIconButtonPreparedBitmaps(Window->ScreenID,BITS8X,BITS8Y,
  460.             BITS8WIDTH,BITS8HEIGHT,Bits8Unselected,Bits8MouseDown,Bits8Selected,Bits8Selected,
  461.             eIconRadioMode);
  462.         if (Window->Bits8Button == NIL)
  463.             {
  464.              FailurePoint25:
  465.                 DisposeIconButton(Window->StereoButton);
  466.                 goto FailurePoint24;
  467.             }
  468.  
  469.         Window->Bits16Button = NewIconButtonPreparedBitmaps(Window->ScreenID,BITS16X,BITS16Y,
  470.             BITS16WIDTH,BITS16HEIGHT,Bits16Unselected,Bits16MouseDown,Bits16Selected,
  471.             Bits16Selected,eIconRadioMode);
  472.         if (Window->Bits16Button == NIL)
  473.             {
  474.              FailurePoint26:
  475.                 DisposeIconButton(Window->Bits8Button);
  476.                 goto FailurePoint25;
  477.             }
  478.         switch (AlgoSampObjectGetNumBits(AlgoSampObject))
  479.             {
  480.                 case eSample16bit:
  481.                     SetIconButtonState(Window->Bits16Button,True);
  482.                     break;
  483.                 case eSample8bit:
  484.                     SetIconButtonState(Window->Bits8Button,True);
  485.                     break;
  486.                 default:
  487.                     EXECUTE(PRERR(ForceAbort,"NewAlgoSampWindow:  bad num bits value"));
  488.                     break;
  489.             }
  490.  
  491.         Window->BodyEdit = NewTextEdit(Window->ScreenID,
  492.             (TEScrollType)(eTEVScrollBar | eTEHScrollBar),GetMonospacedFont(),9,
  493.             BODYX,BODYY + FontHeight,BODYWIDTH(WinWidth),BODYHEIGHT(WinHeight) - FontHeight);
  494.         if (Window->BodyEdit == NIL)
  495.             {
  496.              FailurePoint27:
  497.                 DisposeIconButton(Window->Bits16Button);
  498.                 goto FailurePoint26;
  499.             }
  500.         SetTextEditTabSize(Window->BodyEdit,MainWindowGetTabSize(MainWindow));
  501.         StringTemp = AlgoSampObjectGetFormulaCopy(AlgoSampObject);
  502.         if (StringTemp == NIL)
  503.             {
  504.              FailurePoint28:
  505.                 DisposeTextEdit(Window->BodyEdit);
  506.                 goto FailurePoint27;
  507.             }
  508.         TextEditNewRawData(Window->BodyEdit,StringTemp,"\x0a");
  509.         ReleasePtr(StringTemp);
  510.         TextEditHasBeenSaved(Window->BodyEdit);
  511.         SetTextEditAutoIndent(Window->BodyEdit,True);
  512.  
  513.         Window->MyGenericWindow = CheckInNewWindow(Window->ScreenID,Window,
  514.             (void (*)(void*,MyBoolean,OrdType,OrdType,ModifierFlags))&AlgoSampWindowDoIdle,
  515.             (void (*)(void*))&AlgoSampWindowBecomeActive,
  516.             (void (*)(void*))&AlgoSampWindowBecomeInactive,
  517.             (void (*)(void*))&AlgoSampWindowJustResized,
  518.             (void (*)(OrdType,OrdType,ModifierFlags,void*))&AlgoSampWindowDoMouseDown,
  519.             (void (*)(unsigned char,ModifierFlags,void*))&AlgoSampWindowDoKeyDown,
  520.             (void (*)(void*))&AlgoSampWindowClose,
  521.             (void (*)(void*))&AlgoSampWindowMenuSetup,
  522.             (void (*)(void*,MenuItemType*))&AlgoSampWindowDoMenuCommand);
  523.         if (Window->MyGenericWindow == NIL)
  524.             {
  525.              FailurePoint29:
  526.                 goto FailurePoint28;
  527.             }
  528.  
  529.         Window->MyMenuItem = MakeNewMenuItem(mmWindowMenu,"x",0);
  530.         if (Window->MyMenuItem == NIL)
  531.             {
  532.              FailurePoint30:
  533.                 CheckOutDyingWindow(Window->MyGenericWindow);
  534.                 goto FailurePoint29;
  535.             }
  536.         if (!RegisterWindowMenuItem(Window->MyMenuItem,(void (*)(void*))&ActivateThisWindow,
  537.             Window->ScreenID))
  538.             {
  539.              FailurePoint31:
  540.                 KillMenuItem(Window->MyMenuItem);
  541.                 goto FailurePoint30;
  542.             }
  543.  
  544.         AlgoSampWindowResetTitlebar(Window);
  545.         Window->ActiveTextEdit = Window->BodyEdit;
  546.  
  547.         return Window;
  548.     }
  549.  
  550.  
  551. /* write back modified data and dispose of the window */
  552. void                                DisposeAlgoSampWindow(AlgoSampWindowRec* Window)
  553.     {
  554.         CheckPtrExistence(Window);
  555.  
  556.         /* save data */
  557.         if (!AlgoSampWindowWritebackModifiedData(Window))
  558.             {
  559.                 /* failed -- now what? */
  560.             }
  561.  
  562.         AlgoSampObjectClosingWindowNotify(Window->AlgoSampObject,
  563.             GetWindowXStart(Window->ScreenID),GetWindowYStart(Window->ScreenID),
  564.             GetWindowWidth(Window->ScreenID),GetWindowHeight(Window->ScreenID));
  565.         DeregisterWindowMenuItem(Window->MyMenuItem);
  566.         KillMenuItem(Window->MyMenuItem);
  567.         CheckOutDyingWindow(Window->MyGenericWindow);
  568.         DisposeTextEdit(Window->NameEdit);
  569.         DisposeTextEdit(Window->BodyEdit);
  570.         DisposeTextEdit(Window->SamplingRateEdit);
  571.         DisposeTextEdit(Window->OriginEdit);
  572.         DisposeTextEdit(Window->NaturalFrequencyEdit);
  573.         DisposeTextEdit(Window->LoopStartEdit1);
  574.         DisposeTextEdit(Window->LoopStartEdit2);
  575.         DisposeTextEdit(Window->LoopStartEdit3);
  576.         DisposeTextEdit(Window->LoopEndEdit1);
  577.         DisposeTextEdit(Window->LoopEndEdit2);
  578.         DisposeTextEdit(Window->LoopEndEdit3);
  579.         DisposeIconButton(Window->StereoButton);
  580.         DisposeIconButton(Window->MonoButton);
  581.         DisposeIconButton(Window->Bits16Button);
  582.         DisposeIconButton(Window->Bits8Button);
  583.         KillWindow(Window->ScreenID);
  584.         ReleasePtr((char*)Window);
  585.     }
  586.  
  587.  
  588. /* return True if the data in the window has been changed since the last */
  589. /* time the file was saved. */
  590. MyBoolean                        HasAlgoSampWindowBeenModified(AlgoSampWindowRec* Window)
  591.     {
  592.         CheckPtrExistence(Window);
  593.         return Window->BitsButtonChanged || Window->ChannelsButtonChanged
  594.             || TextEditDoesItNeedToBeSaved(Window->NameEdit)
  595.             || TextEditDoesItNeedToBeSaved(Window->BodyEdit)
  596.             || TextEditDoesItNeedToBeSaved(Window->SamplingRateEdit)
  597.             || TextEditDoesItNeedToBeSaved(Window->OriginEdit)
  598.             || TextEditDoesItNeedToBeSaved(Window->NaturalFrequencyEdit)
  599.             || TextEditDoesItNeedToBeSaved(Window->LoopStartEdit1)
  600.             || TextEditDoesItNeedToBeSaved(Window->LoopStartEdit2)
  601.             || TextEditDoesItNeedToBeSaved(Window->LoopStartEdit3)
  602.             || TextEditDoesItNeedToBeSaved(Window->LoopEndEdit1)
  603.             || TextEditDoesItNeedToBeSaved(Window->LoopEndEdit2)
  604.             || TextEditDoesItNeedToBeSaved(Window->LoopEndEdit3);
  605.     }
  606.  
  607.  
  608. /* highlight the specified line number in the formula window. */
  609. void                                AlgoSampWindowHiliteLine(AlgoSampWindowRec* Window,
  610.                                             long LineNumber)
  611.     {
  612.         CheckPtrExistence(Window);
  613.         if (Window->ActiveTextEdit != Window->BodyEdit)
  614.             {
  615.                 DisableTextEditSelection(Window->ActiveTextEdit);
  616.                 Window->ActiveTextEdit = Window->BodyEdit;
  617.                 EnableTextEditSelection(Window->ActiveTextEdit);
  618.             }
  619.         SetTextEditSelection(Window->BodyEdit,LineNumber,0,LineNumber + 1,0);
  620.         TextEditShowSelection(Window->BodyEdit);
  621.     }
  622.  
  623.  
  624. /* bring the window to the top and give it the focus */
  625. void                                AlgoSampWindowBringToTop(AlgoSampWindowRec* Window)
  626.     {
  627.         CheckPtrExistence(Window);
  628.         ActivateThisWindow(Window->ScreenID);
  629.     }
  630.  
  631.  
  632. void                                AlgoSampWindowDoIdle(AlgoSampWindowRec* Window,
  633.                                             MyBoolean CheckCursorFlag, OrdType XLoc, OrdType YLoc,
  634.                                             ModifierFlags Modifiers)
  635.     {
  636.         CheckPtrExistence(Window);
  637.         TextEditUpdateCursor(Window->ActiveTextEdit);
  638.         if (CheckCursorFlag)
  639.             {
  640.                 if (TextEditIBeamTest(Window->NameEdit,XLoc,YLoc)
  641.                     || TextEditIBeamTest(Window->BodyEdit,XLoc,YLoc)
  642.                     || TextEditIBeamTest(Window->SamplingRateEdit,XLoc,YLoc)
  643.                     || TextEditIBeamTest(Window->OriginEdit,XLoc,YLoc)
  644.                     || TextEditIBeamTest(Window->NaturalFrequencyEdit,XLoc,YLoc)
  645.                     || TextEditIBeamTest(Window->LoopStartEdit1,XLoc,YLoc)
  646.                     || TextEditIBeamTest(Window->LoopStartEdit2,XLoc,YLoc)
  647.                     || TextEditIBeamTest(Window->LoopStartEdit3,XLoc,YLoc)
  648.                     || TextEditIBeamTest(Window->LoopEndEdit1,XLoc,YLoc)
  649.                     || TextEditIBeamTest(Window->LoopEndEdit2,XLoc,YLoc)
  650.                     || TextEditIBeamTest(Window->LoopEndEdit3,XLoc,YLoc))
  651.                     {
  652.                         SetIBeamCursor();
  653.                     }
  654.                  else
  655.                     {
  656.                         SetArrowCursor();
  657.                     }
  658.             }
  659.     }
  660.  
  661.  
  662. void                                AlgoSampWindowBecomeActive(AlgoSampWindowRec* Window)
  663.     {
  664.         OrdType                        XSize;
  665.         OrdType                        YSize;
  666.  
  667.         CheckPtrExistence(Window);
  668.         EnableTextEditSelection(Window->ActiveTextEdit);
  669.         XSize = GetWindowWidth(Window->ScreenID);
  670.         YSize = GetWindowHeight(Window->ScreenID);
  671.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  672.         DrawBitmap(Window->ScreenID,XSize-15,YSize-15,GetGrowIcon(True/*enablegrowicon*/));
  673.     }
  674.  
  675.  
  676. void                                AlgoSampWindowBecomeInactive(AlgoSampWindowRec* Window)
  677.     {
  678.         OrdType                        XSize;
  679.         OrdType                        YSize;
  680.  
  681.         CheckPtrExistence(Window);
  682.         DisableTextEditSelection(Window->ActiveTextEdit);
  683.         XSize = GetWindowWidth(Window->ScreenID);
  684.         YSize = GetWindowHeight(Window->ScreenID);
  685.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  686.         DrawBitmap(Window->ScreenID,XSize-15,YSize-15,GetGrowIcon(False/*disablegrowicon*/));
  687.     }
  688.  
  689.  
  690. void                                AlgoSampWindowJustResized(AlgoSampWindowRec* Window)
  691.     {
  692.         OrdType                        XSize;
  693.         OrdType                        YSize;
  694.         OrdType                        FontHeight;
  695.  
  696.         CheckPtrExistence(Window);
  697.         XSize = GetWindowWidth(Window->ScreenID);
  698.         YSize = GetWindowHeight(Window->ScreenID);
  699.         SetClipRect(Window->ScreenID,0,0,XSize,YSize);
  700.         DrawBoxErase(Window->ScreenID,0,0,XSize,YSize);
  701.         FontHeight = GetFontHeight(GetScreenFont(),9);
  702.         SetTextEditPosition(Window->BodyEdit,
  703.             BODYX,BODYY + FontHeight,BODYWIDTH(XSize),BODYHEIGHT(YSize) - FontHeight);
  704.     }
  705.  
  706.  
  707. void                                AlgoSampWindowDoMouseDown(OrdType XLoc, OrdType YLoc,
  708.                                             ModifierFlags Modifiers, AlgoSampWindowRec* Window)
  709.     {
  710.         CheckPtrExistence(Window);
  711.         if ((XLoc >= GetWindowWidth(Window->ScreenID) - 15)
  712.             && (XLoc < GetWindowWidth(Window->ScreenID))
  713.             && (YLoc >= GetWindowHeight(Window->ScreenID) - 15)
  714.             && (YLoc < GetWindowHeight(Window->ScreenID)))
  715.             {
  716.                 UserGrowWindow(Window->ScreenID,XLoc,YLoc);
  717.                 AlgoSampWindowJustResized(Window);
  718.             }
  719.         else if (TextEditHitTest(Window->NameEdit,XLoc,YLoc))
  720.             {
  721.                 if (Window->ActiveTextEdit != Window->NameEdit)
  722.                     {
  723.                         DisableTextEditSelection(Window->ActiveTextEdit);
  724.                         Window->ActiveTextEdit = Window->NameEdit;
  725.                         EnableTextEditSelection(Window->ActiveTextEdit);
  726.                     }
  727.                 TextEditDoMouseDown(Window->NameEdit,XLoc,YLoc,Modifiers);
  728.             }
  729.         else if (TextEditHitTest(Window->BodyEdit,XLoc,YLoc))
  730.             {
  731.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  732.                     {
  733.                         DisableTextEditSelection(Window->ActiveTextEdit);
  734.                         Window->ActiveTextEdit = Window->BodyEdit;
  735.                         EnableTextEditSelection(Window->ActiveTextEdit);
  736.                     }
  737.                 TextEditDoMouseDown(Window->BodyEdit,XLoc,YLoc,Modifiers);
  738.             }
  739.         else if (TextEditHitTest(Window->SamplingRateEdit,XLoc,YLoc))
  740.             {
  741.                 if (Window->ActiveTextEdit != Window->SamplingRateEdit)
  742.                     {
  743.                         DisableTextEditSelection(Window->ActiveTextEdit);
  744.                         Window->ActiveTextEdit = Window->SamplingRateEdit;
  745.                         EnableTextEditSelection(Window->ActiveTextEdit);
  746.                     }
  747.                 TextEditDoMouseDown(Window->SamplingRateEdit,XLoc,YLoc,Modifiers);
  748.             }
  749.         else if (TextEditHitTest(Window->OriginEdit,XLoc,YLoc))
  750.             {
  751.                 if (Window->ActiveTextEdit != Window->OriginEdit)
  752.                     {
  753.                         DisableTextEditSelection(Window->ActiveTextEdit);
  754.                         Window->ActiveTextEdit = Window->OriginEdit;
  755.                         EnableTextEditSelection(Window->ActiveTextEdit);
  756.                     }
  757.                 TextEditDoMouseDown(Window->OriginEdit,XLoc,YLoc,Modifiers);
  758.             }
  759.         else if (TextEditHitTest(Window->NaturalFrequencyEdit,XLoc,YLoc))
  760.             {
  761.                 if (Window->ActiveTextEdit != Window->NaturalFrequencyEdit)
  762.                     {
  763.                         DisableTextEditSelection(Window->ActiveTextEdit);
  764.                         Window->ActiveTextEdit = Window->NaturalFrequencyEdit;
  765.                         EnableTextEditSelection(Window->ActiveTextEdit);
  766.                     }
  767.                 TextEditDoMouseDown(Window->NaturalFrequencyEdit,XLoc,YLoc,Modifiers);
  768.             }
  769.         else if (TextEditHitTest(Window->LoopStartEdit1,XLoc,YLoc))
  770.             {
  771.                 if (Window->ActiveTextEdit != Window->LoopStartEdit1)
  772.                     {
  773.                         DisableTextEditSelection(Window->ActiveTextEdit);
  774.                         Window->ActiveTextEdit = Window->LoopStartEdit1;
  775.                         EnableTextEditSelection(Window->ActiveTextEdit);
  776.                     }
  777.                 TextEditDoMouseDown(Window->LoopStartEdit1,XLoc,YLoc,Modifiers);
  778.             }
  779.         else if (TextEditHitTest(Window->LoopStartEdit2,XLoc,YLoc))
  780.             {
  781.                 if (Window->ActiveTextEdit != Window->LoopStartEdit2)
  782.                     {
  783.                         DisableTextEditSelection(Window->ActiveTextEdit);
  784.                         Window->ActiveTextEdit = Window->LoopStartEdit2;
  785.                         EnableTextEditSelection(Window->ActiveTextEdit);
  786.                     }
  787.                 TextEditDoMouseDown(Window->LoopStartEdit2,XLoc,YLoc,Modifiers);
  788.             }
  789.         else if (TextEditHitTest(Window->LoopStartEdit3,XLoc,YLoc))
  790.             {
  791.                 if (Window->ActiveTextEdit != Window->LoopStartEdit3)
  792.                     {
  793.                         DisableTextEditSelection(Window->ActiveTextEdit);
  794.                         Window->ActiveTextEdit = Window->LoopStartEdit3;
  795.                         EnableTextEditSelection(Window->ActiveTextEdit);
  796.                     }
  797.                 TextEditDoMouseDown(Window->LoopStartEdit3,XLoc,YLoc,Modifiers);
  798.             }
  799.         else if (TextEditHitTest(Window->LoopEndEdit1,XLoc,YLoc))
  800.             {
  801.                 if (Window->ActiveTextEdit != Window->LoopEndEdit1)
  802.                     {
  803.                         DisableTextEditSelection(Window->ActiveTextEdit);
  804.                         Window->ActiveTextEdit = Window->LoopEndEdit1;
  805.                         EnableTextEditSelection(Window->ActiveTextEdit);
  806.                     }
  807.                 TextEditDoMouseDown(Window->LoopEndEdit1,XLoc,YLoc,Modifiers);
  808.             }
  809.         else if (TextEditHitTest(Window->LoopEndEdit2,XLoc,YLoc))
  810.             {
  811.                 if (Window->ActiveTextEdit != Window->LoopEndEdit2)
  812.                     {
  813.                         DisableTextEditSelection(Window->ActiveTextEdit);
  814.                         Window->ActiveTextEdit = Window->LoopEndEdit2;
  815.                         EnableTextEditSelection(Window->ActiveTextEdit);
  816.                     }
  817.                 TextEditDoMouseDown(Window->LoopEndEdit2,XLoc,YLoc,Modifiers);
  818.             }
  819.         else if (TextEditHitTest(Window->LoopEndEdit3,XLoc,YLoc))
  820.             {
  821.                 if (Window->ActiveTextEdit != Window->LoopEndEdit3)
  822.                     {
  823.                         DisableTextEditSelection(Window->ActiveTextEdit);
  824.                         Window->ActiveTextEdit = Window->LoopEndEdit3;
  825.                         EnableTextEditSelection(Window->ActiveTextEdit);
  826.                     }
  827.                 TextEditDoMouseDown(Window->LoopEndEdit3,XLoc,YLoc,Modifiers);
  828.             }
  829.         else if (IconButtonHitTest(Window->MonoButton,XLoc,YLoc))
  830.             {
  831.                 if (IconButtonMouseDown(Window->MonoButton,XLoc,YLoc,NIL,NIL))
  832.                     {
  833.                         Window->ChannelsButtonChanged = True;
  834.                         SetIconButtonState(Window->StereoButton,False);
  835.                     }
  836.             }
  837.         else if (IconButtonHitTest(Window->StereoButton,XLoc,YLoc))
  838.             {
  839.                 if (IconButtonMouseDown(Window->StereoButton,XLoc,YLoc,NIL,NIL))
  840.                     {
  841.                         Window->ChannelsButtonChanged = True;
  842.                         SetIconButtonState(Window->MonoButton,False);
  843.                     }
  844.             }
  845.         else if (IconButtonHitTest(Window->Bits8Button,XLoc,YLoc))
  846.             {
  847.                 if (IconButtonMouseDown(Window->Bits8Button,XLoc,YLoc,NIL,NIL))
  848.                     {
  849.                         Window->BitsButtonChanged = True;
  850.                         SetIconButtonState(Window->Bits16Button,False);
  851.                     }
  852.             }
  853.         else if (IconButtonHitTest(Window->Bits16Button,XLoc,YLoc))
  854.             {
  855.                 if (IconButtonMouseDown(Window->Bits16Button,XLoc,YLoc,NIL,NIL))
  856.                     {
  857.                         Window->BitsButtonChanged = True;
  858.                         SetIconButtonState(Window->Bits8Button,False);
  859.                     }
  860.             }
  861.     }
  862.  
  863.  
  864. void                                AlgoSampWindowDoKeyDown(unsigned char KeyCode,
  865.                                             ModifierFlags Modifiers,AlgoSampWindowRec* Window)
  866.     {
  867.         CheckPtrExistence(Window);
  868.         if ((KeyCode == 9) && (Window->ActiveTextEdit != Window->BodyEdit))
  869.             {
  870.                 DisableTextEditSelection(Window->ActiveTextEdit);
  871.                 if ((Modifiers & eShiftKey) != 0)
  872.                     {
  873.                         /* backwards */
  874.                         if (Window->ActiveTextEdit == Window->LoopEndEdit3)
  875.                             {
  876.                                 Window->ActiveTextEdit = Window->LoopStartEdit3;
  877.                             }
  878.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit3)
  879.                             {
  880.                                 Window->ActiveTextEdit = Window->LoopEndEdit2;
  881.                             }
  882.                         else if (Window->ActiveTextEdit == Window->LoopEndEdit2)
  883.                             {
  884.                                 Window->ActiveTextEdit = Window->LoopStartEdit2;
  885.                             }
  886.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit2)
  887.                             {
  888.                                 Window->ActiveTextEdit = Window->LoopEndEdit1;
  889.                             }
  890.                         else if (Window->ActiveTextEdit == Window->LoopEndEdit1)
  891.                             {
  892.                                 Window->ActiveTextEdit = Window->LoopStartEdit1;
  893.                             }
  894.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit1)
  895.                             {
  896.                                 Window->ActiveTextEdit = Window->NaturalFrequencyEdit;
  897.                             }
  898.                         else if (Window->ActiveTextEdit == Window->NaturalFrequencyEdit)
  899.                             {
  900.                                 Window->ActiveTextEdit = Window->OriginEdit;
  901.                             }
  902.                         else if (Window->ActiveTextEdit == Window->OriginEdit)
  903.                             {
  904.                                 Window->ActiveTextEdit = Window->SamplingRateEdit;
  905.                             }
  906.                         else if (Window->ActiveTextEdit == Window->SamplingRateEdit)
  907.                             {
  908.                                 Window->ActiveTextEdit = Window->NameEdit;
  909.                             }
  910.                         else
  911.                             {
  912.                                 Window->ActiveTextEdit = Window->LoopEndEdit3;
  913.                             }
  914.                     }
  915.                  else
  916.                     {
  917.                         /* forwards */
  918.                         if (Window->ActiveTextEdit == Window->NameEdit)
  919.                             {
  920.                                 Window->ActiveTextEdit = Window->SamplingRateEdit;
  921.                             }
  922.                         else if (Window->ActiveTextEdit == Window->SamplingRateEdit)
  923.                             {
  924.                                 Window->ActiveTextEdit = Window->OriginEdit;
  925.                             }
  926.                         else if (Window->ActiveTextEdit == Window->OriginEdit)
  927.                             {
  928.                                 Window->ActiveTextEdit = Window->NaturalFrequencyEdit;
  929.                             }
  930.                         else if (Window->ActiveTextEdit == Window->NaturalFrequencyEdit)
  931.                             {
  932.                                 Window->ActiveTextEdit = Window->LoopStartEdit1;
  933.                             }
  934.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit1)
  935.                             {
  936.                                 Window->ActiveTextEdit = Window->LoopEndEdit1;
  937.                             }
  938.                         else if (Window->ActiveTextEdit == Window->LoopEndEdit1)
  939.                             {
  940.                                 Window->ActiveTextEdit = Window->LoopStartEdit2;
  941.                             }
  942.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit2)
  943.                             {
  944.                                 Window->ActiveTextEdit = Window->LoopEndEdit2;
  945.                             }
  946.                         else if (Window->ActiveTextEdit == Window->LoopEndEdit2)
  947.                             {
  948.                                 Window->ActiveTextEdit = Window->LoopStartEdit3;
  949.                             }
  950.                         else if (Window->ActiveTextEdit == Window->LoopStartEdit3)
  951.                             {
  952.                                 Window->ActiveTextEdit = Window->LoopEndEdit3;
  953.                             }
  954.                         else
  955.                             {
  956.                                 Window->ActiveTextEdit = Window->NameEdit;
  957.                             }
  958.                     }
  959.                 EnableTextEditSelection(Window->ActiveTextEdit);
  960.                 TextEditDoMenuSelectAll(Window->ActiveTextEdit);
  961.             }
  962.         else
  963.             {
  964.                 TextEditDoKeyPressed(Window->ActiveTextEdit,KeyCode,Modifiers);
  965.             }
  966.     }
  967.  
  968.  
  969. void                                AlgoSampWindowClose(AlgoSampWindowRec* Window)
  970.     {
  971.         CheckPtrExistence(Window);
  972.         DisposeAlgoSampWindow(Window);
  973.     }
  974.  
  975.  
  976. void                                AlgoSampWindowUpdator(AlgoSampWindowRec* Window)
  977.     {
  978.         OrdType            XSize;
  979.         OrdType            YSize;
  980.         FontType        ScreenFont;
  981.  
  982.         CheckPtrExistence(Window);
  983.         ScreenFont = GetScreenFont();
  984.         TextEditFullRedraw(Window->NameEdit);
  985.         TextEditFullRedraw(Window->BodyEdit);
  986.         TextEditFullRedraw(Window->SamplingRateEdit);
  987.         TextEditFullRedraw(Window->OriginEdit);
  988.         TextEditFullRedraw(Window->NaturalFrequencyEdit);
  989.         TextEditFullRedraw(Window->LoopStartEdit1);
  990.         TextEditFullRedraw(Window->LoopStartEdit2);
  991.         TextEditFullRedraw(Window->LoopStartEdit3);
  992.         TextEditFullRedraw(Window->LoopEndEdit1);
  993.         TextEditFullRedraw(Window->LoopEndEdit2);
  994.         TextEditFullRedraw(Window->LoopEndEdit3);
  995.         RedrawIconButton(Window->Bits16Button);
  996.         RedrawIconButton(Window->Bits8Button);
  997.         RedrawIconButton(Window->MonoButton);
  998.         RedrawIconButton(Window->StereoButton);
  999.         XSize = GetWindowWidth(Window->ScreenID);
  1000.         YSize = GetWindowHeight(Window->ScreenID);
  1001.         SetClipRect(Window->ScreenID,0,0,XSize,YSize);
  1002.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Sample Name:",12,
  1003.             SAMPLENAMEX,SAMPLENAMEY,ePlain);
  1004.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Sampling Rate:",14,
  1005.             SAMPLERATEX,SAMPLERATEY,ePlain);
  1006.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Origin:",7,ORIGINX,ORIGINY,ePlain);
  1007.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Natural Freq:",13,
  1008.             BASEFREQX,BASEFREQY,ePlain);
  1009.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop Start 1:",13,
  1010.             LOOPSTART1X,LOOPSTART1Y,ePlain);
  1011.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop Start 2:",13,
  1012.             LOOPSTART2X,LOOPSTART2Y,ePlain);
  1013.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop Start 3:",13,
  1014.             LOOPSTART3X,LOOPSTART3Y,ePlain);
  1015.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop End 1:",11,
  1016.             LOOPEND1X,LOOPEND1Y,ePlain);
  1017.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop End 2:",11,
  1018.             LOOPEND2X,LOOPEND2Y,ePlain);
  1019.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Loop End 3:",11,
  1020.             LOOPEND3X,LOOPEND3Y,ePlain);
  1021.         DrawTextLine(Window->ScreenID,ScreenFont,9,"Waveform Generating Function:",29,
  1022.             BODYX + TITLEINDENT,BODYY,eBold);
  1023.         SetClipRect(Window->ScreenID,XSize - 15,YSize - 15,XSize,YSize);
  1024.         DrawBitmap(Window->ScreenID,XSize-15,YSize-15,
  1025.             GetGrowIcon(Window->MyGenericWindow == GetCurrentWindowID()));
  1026.     }
  1027.  
  1028.  
  1029. void                                AlgoSampWindowMenuSetup(AlgoSampWindowRec* Window)
  1030.     {
  1031.         CheckPtrExistence(Window);
  1032.         MainWindowEnableGlobalMenus(Window->MainWindow);
  1033.         EnableMenuItem(mPaste);
  1034.         ChangeItemName(mPaste,"Paste Text");
  1035.         if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  1036.             {
  1037.                 EnableMenuItem(mCut);
  1038.                 ChangeItemName(mCut,"Cut Text");
  1039.                 EnableMenuItem(mCopy);
  1040.                 ChangeItemName(mCopy,"Copy Text");
  1041.                 EnableMenuItem(mClear);
  1042.                 ChangeItemName(mClear,"Clear Text");
  1043.             }
  1044.         EnableMenuItem(mShiftLeft);
  1045.         EnableMenuItem(mShiftRight);
  1046.         EnableMenuItem(mBalanceParens);
  1047.         EnableMenuItem(mSelectAll);
  1048.         ChangeItemName(mSelectAll,"Select All Text");
  1049.         if (TextEditCanWeUndo(Window->ActiveTextEdit))
  1050.             {
  1051.                 EnableMenuItem(mUndo);
  1052.                 ChangeItemName(mUndo,"Undo Text Change");
  1053.             }
  1054.         ChangeItemName(mCloseFile,"Close Algorithmic Sample Editor");
  1055.         EnableMenuItem(mCloseFile);
  1056.         ChangeItemName(mBuildFunction,"Build Sample");
  1057.         EnableMenuItem(mBuildFunction);
  1058.         ChangeItemName(mUnbuildFunction,"Unbuild Sample");
  1059.         EnableMenuItem(mUnbuildFunction);
  1060.         ChangeItemName(mAlgoSampToSample,"Open Algorithmic Sample As New Sample");
  1061.         EnableMenuItem(mAlgoSampToSample);
  1062.         ChangeItemName(mDeleteObject,"Delete Algorithmic Sample");
  1063.         EnableMenuItem(mDeleteObject);
  1064.         EnableMenuItem(mFind);
  1065.         if (PtrSize(GlobalSearchString) != 0)
  1066.             {
  1067.                 EnableMenuItem(mFindAgain);
  1068.                 if ((Window->ActiveTextEdit != NIL)
  1069.                     && TextEditIsThereValidSelection(Window->ActiveTextEdit))
  1070.                     {
  1071.                         EnableMenuItem(mReplace);
  1072.                         EnableMenuItem(mReplaceAndFindAgain);
  1073.                     }
  1074.             }
  1075.         EnableMenuItem(mShowSelection);
  1076.         if ((Window->ActiveTextEdit != NIL)
  1077.             && TextEditIsThereValidSelection(Window->ActiveTextEdit))
  1078.             {
  1079.                 EnableMenuItem(mEnterSelection);
  1080.             }
  1081.         SetItemCheckmark(Window->MyMenuItem);
  1082.     }
  1083.  
  1084.  
  1085. void                                AlgoSampWindowDoMenuCommand(AlgoSampWindowRec* Window,
  1086.                                             MenuItemType* MenuItem)
  1087.     {
  1088.         CheckPtrExistence(Window);
  1089.         if (MainWindowDoGlobalMenuItem(Window->MainWindow,MenuItem))
  1090.             {
  1091.             }
  1092.         else if (MenuItem == mPaste)
  1093.             {
  1094.                 TextEditDoMenuPaste(Window->ActiveTextEdit);
  1095.             }
  1096.         else if (MenuItem == mCut)
  1097.             {
  1098.                 TextEditDoMenuCut(Window->ActiveTextEdit);
  1099.             }
  1100.         else if (MenuItem == mCopy)
  1101.             {
  1102.                 TextEditDoMenuCopy(Window->ActiveTextEdit);
  1103.             }
  1104.         else if (MenuItem == mClear)
  1105.             {
  1106.                 TextEditDoMenuClear(Window->ActiveTextEdit);
  1107.             }
  1108.         else if (MenuItem == mSelectAll)
  1109.             {
  1110.                 TextEditDoMenuSelectAll(Window->ActiveTextEdit);
  1111.             }
  1112.         else if (MenuItem == mUndo)
  1113.             {
  1114.                 TextEditDoMenuUndo(Window->ActiveTextEdit);
  1115.             }
  1116.         else if (MenuItem == mCloseFile)
  1117.             {
  1118.                 AlgoSampWindowClose(Window);
  1119.             }
  1120.         else if (MenuItem == mShiftLeft)
  1121.             {
  1122.                 TextEditShiftSelectionLeftOneTab(Window->ActiveTextEdit);
  1123.             }
  1124.         else if (MenuItem == mShiftRight)
  1125.             {
  1126.                 TextEditShiftSelectionRightOneTab(Window->ActiveTextEdit);
  1127.             }
  1128.         else if (MenuItem == mBalanceParens)
  1129.             {
  1130.                 TextEditBalanceParens(Window->ActiveTextEdit);
  1131.             }
  1132.         else if (MenuItem == mBuildFunction)
  1133.             {
  1134.                 AlgoSampObjectBuild(Window->AlgoSampObject);
  1135.             }
  1136.         else if (MenuItem == mUnbuildFunction)
  1137.             {
  1138.                 AlgoSampObjectUnbuild(Window->AlgoSampObject);
  1139.             }
  1140.         else if (MenuItem == mAlgoSampToSample)
  1141.             {
  1142.                 if (AlgoSampObjectMakeUpToDate(Window->AlgoSampObject))
  1143.                     {
  1144.                         MainWindowCopyRawSampleAndOpen(Window->MainWindow,
  1145.                             AlgoSampObjectGetRawData(Window->AlgoSampObject),
  1146.                             AlgoSampObjectGetNumBits(Window->AlgoSampObject),
  1147.                             AlgoSampObjectGetNumChannels(Window->AlgoSampObject),
  1148.                             AlgoSampObjectGetOrigin(Window->AlgoSampObject),
  1149.                             AlgoSampObjectGetLoopStart1(Window->AlgoSampObject),
  1150.                             AlgoSampObjectGetLoopStart2(Window->AlgoSampObject),
  1151.                             AlgoSampObjectGetLoopStart3(Window->AlgoSampObject),
  1152.                             AlgoSampObjectGetLoopEnd1(Window->AlgoSampObject),
  1153.                             AlgoSampObjectGetLoopEnd2(Window->AlgoSampObject),
  1154.                             AlgoSampObjectGetLoopEnd3(Window->AlgoSampObject),
  1155.                             AlgoSampObjectGetSamplingRate(Window->AlgoSampObject),
  1156.                             AlgoSampObjectGetNaturalFrequency(Window->AlgoSampObject));
  1157.                     }
  1158.             }
  1159.         else if (MenuItem == mDeleteObject)
  1160.             {
  1161.                 AlgoSampListDeleteAlgoSamp(Window->AlgoSampList,Window->AlgoSampObject);
  1162.             }
  1163.         else if (MenuItem == mFind)
  1164.             {
  1165.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  1166.                     {
  1167.                         DisableTextEditSelection(Window->ActiveTextEdit);
  1168.                         Window->ActiveTextEdit = Window->BodyEdit;
  1169.                         EnableTextEditSelection(Window->ActiveTextEdit);
  1170.                     }
  1171.                 switch (DoFindDialog(&GlobalSearchString,&GlobalReplaceString,
  1172.                     mCut,mPaste,mCopy,mUndo,mSelectAll,mClear))
  1173.                     {
  1174.                         default:
  1175.                             EXECUTE(PRERR(ForceAbort,
  1176.                                 "AlgoSampWindowDoMenuCommand:  bad value from DoFindDialog"));
  1177.                             break;
  1178.                         case eFindCancel:
  1179.                         case eDontFind:
  1180.                             break;
  1181.                         case eFindFromStart:
  1182.                             SetTextEditInsertionPoint(Window->ActiveTextEdit,0,0);
  1183.                             TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  1184.                             TextEditShowSelection(Window->ActiveTextEdit);
  1185.                             break;
  1186.                         case eFindAgain:
  1187.                             TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  1188.                             TextEditShowSelection(Window->ActiveTextEdit);
  1189.                             break;
  1190.                     }
  1191.             }
  1192.         else if (MenuItem == mFindAgain)
  1193.             {
  1194.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  1195.                     {
  1196.                         DisableTextEditSelection(Window->ActiveTextEdit);
  1197.                         Window->ActiveTextEdit = Window->BodyEdit;
  1198.                         EnableTextEditSelection(Window->ActiveTextEdit);
  1199.                     }
  1200.                 TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  1201.                 TextEditShowSelection(Window->ActiveTextEdit);
  1202.             }
  1203.         else if (MenuItem == mReplace)
  1204.             {
  1205.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  1206.                     {
  1207.                         DisableTextEditSelection(Window->ActiveTextEdit);
  1208.                         Window->ActiveTextEdit = Window->BodyEdit;
  1209.                         EnableTextEditSelection(Window->ActiveTextEdit);
  1210.                     }
  1211.                 if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  1212.                     {
  1213.                         TextEditInsertRawDataWithUndo(Window->ActiveTextEdit,GlobalReplaceString,
  1214.                             SYSTEMLINEFEED);
  1215.                     }
  1216.             }
  1217.         else if (MenuItem == mReplaceAndFindAgain)
  1218.             {
  1219.                 if (Window->ActiveTextEdit != Window->BodyEdit)
  1220.                     {
  1221.                         DisableTextEditSelection(Window->ActiveTextEdit);
  1222.                         Window->ActiveTextEdit = Window->BodyEdit;
  1223.                         EnableTextEditSelection(Window->ActiveTextEdit);
  1224.                     }
  1225.                 if (TextEditIsThereValidSelection(Window->ActiveTextEdit))
  1226.                     {
  1227.                         TextEditInsertRawDataWithUndo(Window->ActiveTextEdit,GlobalReplaceString,
  1228.                             SYSTEMLINEFEED);
  1229.                         TextEditFindAgain(Window->ActiveTextEdit,GlobalSearchString);
  1230.                         TextEditShowSelection(Window->ActiveTextEdit);
  1231.                     }
  1232.             }
  1233.         else if (MenuItem == mShowSelection)
  1234.             {
  1235.                 TextEditShowSelection(Window->ActiveTextEdit);
  1236.             }
  1237.         else if (MenuItem == mEnterSelection)
  1238.             {
  1239.                 char*                        NewString;
  1240.  
  1241.                 NewString = TextEditGetSelection(Window->ActiveTextEdit);
  1242.                 if (NewString != NIL)
  1243.                     {
  1244.                         ReleasePtr(GlobalSearchString);
  1245.                         GlobalSearchString = NewString;
  1246.                     }
  1247.             }
  1248.         else
  1249.             {
  1250.                 EXECUTE(PRERR(AllowResume,"AlgoSampWindowDoMenuCommand:  unknown menu command"));
  1251.             }
  1252.     }
  1253.  
  1254.  
  1255. /* get a copy of the name of the sample. */
  1256. char*                                AlgoSampWindowGetNameCopy(AlgoSampWindowRec* Window)
  1257.     {
  1258.         char*                            ReturnValue;
  1259.  
  1260.         CheckPtrExistence(Window);
  1261.         ReturnValue = TextEditGetRawData(Window->NameEdit,"\x0a");
  1262.         if (ReturnValue != NIL)
  1263.             {
  1264.                 SetTag(ReturnValue,"AlgoSampNameCopy");
  1265.             }
  1266.         return ReturnValue;
  1267.     }
  1268.  
  1269.  
  1270. /* get a copy of the sample's formula */
  1271. char*                                AlgoSampWindowGetFormulaCopy(AlgoSampWindowRec* Window)
  1272.     {
  1273.         char*                            ReturnValue;
  1274.  
  1275.         CheckPtrExistence(Window);
  1276.         ReturnValue = TextEditGetRawData(Window->BodyEdit,"\x0a");
  1277.         if (ReturnValue != NIL)
  1278.             {
  1279.                 SetTag(ReturnValue,"AlgoSampFormulaCopy");
  1280.             }
  1281.         return ReturnValue;
  1282.     }
  1283.  
  1284.  
  1285. /* get the origin point of the sample */
  1286. long                                AlgoSampWindowGetOrigin(AlgoSampWindowRec* Window)
  1287.     {
  1288.         long                            ReturnValue;
  1289.         char*                            StringTemp;
  1290.  
  1291.         CheckPtrExistence(Window);
  1292.         StringTemp = TextEditGetRawData(Window->OriginEdit,"\x0a");
  1293.         if (StringTemp != NIL)
  1294.             {
  1295.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1296.                 ReleasePtr(StringTemp);
  1297.             }
  1298.          else
  1299.             {
  1300.                 ReturnValue = 0;
  1301.             }
  1302.         return ReturnValue;
  1303.     }
  1304.  
  1305.  
  1306. /* get the first loop start point of the sample */
  1307. long                                AlgoSampWindowGetLoopStart1(AlgoSampWindowRec* Window)
  1308.     {
  1309.         long                            ReturnValue;
  1310.         char*                            StringTemp;
  1311.  
  1312.         CheckPtrExistence(Window);
  1313.         StringTemp = TextEditGetRawData(Window->LoopStartEdit1,"\x0a");
  1314.         if (StringTemp != NIL)
  1315.             {
  1316.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1317.                 ReleasePtr(StringTemp);
  1318.             }
  1319.          else
  1320.             {
  1321.                 ReturnValue = 0;
  1322.             }
  1323.         return ReturnValue;
  1324.     }
  1325.  
  1326.  
  1327. /* get the second loop start point of the sample */
  1328. long                                AlgoSampWindowGetLoopStart2(AlgoSampWindowRec* Window)
  1329.     {
  1330.         long                            ReturnValue;
  1331.         char*                            StringTemp;
  1332.  
  1333.         CheckPtrExistence(Window);
  1334.         StringTemp = TextEditGetRawData(Window->LoopStartEdit2,"\x0a");
  1335.         if (StringTemp != NIL)
  1336.             {
  1337.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1338.                 ReleasePtr(StringTemp);
  1339.             }
  1340.          else
  1341.             {
  1342.                 ReturnValue = 0;
  1343.             }
  1344.         return ReturnValue;
  1345.     }
  1346.  
  1347.  
  1348. /* get the third loop start point of the sample */
  1349. long                                AlgoSampWindowGetLoopStart3(AlgoSampWindowRec* Window)
  1350.     {
  1351.         long                            ReturnValue;
  1352.         char*                            StringTemp;
  1353.  
  1354.         CheckPtrExistence(Window);
  1355.         StringTemp = TextEditGetRawData(Window->LoopStartEdit3,"\x0a");
  1356.         if (StringTemp != NIL)
  1357.             {
  1358.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1359.                 ReleasePtr(StringTemp);
  1360.             }
  1361.          else
  1362.             {
  1363.                 ReturnValue = 0;
  1364.             }
  1365.         return ReturnValue;
  1366.     }
  1367.  
  1368.  
  1369. /* get the first loop end point of the sample */
  1370. long                                AlgoSampWindowGetLoopEnd1(AlgoSampWindowRec* Window)
  1371.     {
  1372.         long                            ReturnValue;
  1373.         char*                            StringTemp;
  1374.  
  1375.         CheckPtrExistence(Window);
  1376.         StringTemp = TextEditGetRawData(Window->LoopEndEdit1,"\x0a");
  1377.         if (StringTemp != NIL)
  1378.             {
  1379.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1380.                 ReleasePtr(StringTemp);
  1381.             }
  1382.          else
  1383.             {
  1384.                 ReturnValue = 0;
  1385.             }
  1386.         return ReturnValue;
  1387.     }
  1388.  
  1389.  
  1390. /* get the second loop end point of the sample */
  1391. long                                AlgoSampWindowGetLoopEnd2(AlgoSampWindowRec* Window)
  1392.     {
  1393.         long                            ReturnValue;
  1394.         char*                            StringTemp;
  1395.  
  1396.         CheckPtrExistence(Window);
  1397.         StringTemp = TextEditGetRawData(Window->LoopEndEdit2,"\x0a");
  1398.         if (StringTemp != NIL)
  1399.             {
  1400.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1401.                 ReleasePtr(StringTemp);
  1402.             }
  1403.          else
  1404.             {
  1405.                 ReturnValue = 0;
  1406.             }
  1407.         return ReturnValue;
  1408.     }
  1409.  
  1410.  
  1411. /* get the third loop end point of the sample */
  1412. long                                AlgoSampWindowGetLoopEnd3(AlgoSampWindowRec* Window)
  1413.     {
  1414.         long                            ReturnValue;
  1415.         char*                            StringTemp;
  1416.  
  1417.         CheckPtrExistence(Window);
  1418.         StringTemp = TextEditGetRawData(Window->LoopEndEdit3,"\x0a");
  1419.         if (StringTemp != NIL)
  1420.             {
  1421.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1422.                 ReleasePtr(StringTemp);
  1423.             }
  1424.          else
  1425.             {
  1426.                 ReturnValue = 0;
  1427.             }
  1428.         return ReturnValue;
  1429.     }
  1430.  
  1431.  
  1432. /* get the natural pitch for playback conversion */
  1433. double                            AlgoSampWindowGetNaturalFrequency(AlgoSampWindowRec* Window)
  1434.     {
  1435.         double                        ReturnValue;
  1436.         char*                            StringTemp;
  1437.  
  1438.         CheckPtrExistence(Window);
  1439.         StringTemp = TextEditGetRawData(Window->NaturalFrequencyEdit,"\x0a");
  1440.         if (StringTemp != NIL)
  1441.             {
  1442.                 ReturnValue = StringToLongDouble(StringTemp,PtrSize(StringTemp));
  1443.                 ReleasePtr(StringTemp);
  1444.             }
  1445.          else
  1446.             {
  1447.                 ReturnValue = 0;
  1448.             }
  1449.         return ReturnValue;
  1450.     }
  1451.  
  1452.  
  1453. /* get the sampling rate */
  1454. long                                AlgoSampWindowGetSamplingRate(AlgoSampWindowRec* Window)
  1455.     {
  1456.         long                            ReturnValue;
  1457.         char*                            StringTemp;
  1458.  
  1459.         CheckPtrExistence(Window);
  1460.         StringTemp = TextEditGetRawData(Window->SamplingRateEdit,"\x0a");
  1461.         if (StringTemp != NIL)
  1462.             {
  1463.                 ReturnValue = StringToInteger(StringTemp,PtrSize(StringTemp));
  1464.                 ReleasePtr(StringTemp);
  1465.             }
  1466.          else
  1467.             {
  1468.                 ReturnValue = 0;
  1469.             }
  1470.         return ReturnValue;
  1471.     }
  1472.  
  1473.  
  1474. /* get the number of bits that the sample uses */
  1475. NumBitsType                    AlgoSampWindowGetNumBits(AlgoSampWindowRec* Window)
  1476.     {
  1477.         CheckPtrExistence(Window);
  1478.         if (GetIconButtonState(Window->Bits16Button))
  1479.             {
  1480.                 return eSample16bit;
  1481.             }
  1482.          else
  1483.             {
  1484.                 return eSample8bit;
  1485.             }
  1486.     }
  1487.  
  1488.  
  1489. /* get the number of channels that the sample uses */
  1490. NumChannelsType            AlgoSampWindowGetNumChannels(AlgoSampWindowRec* Window)
  1491.     {
  1492.         CheckPtrExistence(Window);
  1493.         if (GetIconButtonState(Window->StereoButton))
  1494.             {
  1495.                 return eSampleStereo;
  1496.             }
  1497.          else
  1498.             {
  1499.                 return eSampleMono;
  1500.             }
  1501.     }
  1502.  
  1503.  
  1504. /* the name of the document has changed, so change the title bar.  the caller is */
  1505. /* responsible for disposing of the string, which must be non-null-terminated */
  1506. void                                AlgoSampWindowGlobalNameChange(AlgoSampWindowRec* Window,
  1507.                                             char* NewFilename)
  1508.     {
  1509.         char*                            LocalNameCopy;
  1510.  
  1511.         CheckPtrExistence(Window);
  1512.         CheckPtrExistence(NewFilename);
  1513.         LocalNameCopy = AlgoSampWindowGetNameCopy(Window);
  1514.         if (LocalNameCopy != NIL)
  1515.             {
  1516.                 char*                            SeparatorString;
  1517.  
  1518.                 SeparatorString = StringToBlockCopy(":  ");
  1519.                 if (SeparatorString != NIL)
  1520.                     {
  1521.                         char*                            LeftHalfOfString;
  1522.  
  1523.                         LeftHalfOfString = ConcatBlockCopy(NewFilename,SeparatorString);
  1524.                         if (LeftHalfOfString != NIL)
  1525.                             {
  1526.                                 char*                            TotalString;
  1527.  
  1528.                                 TotalString = ConcatBlockCopy(LeftHalfOfString,LocalNameCopy);
  1529.                                 if (TotalString != NIL)
  1530.                                     {
  1531.                                         char*                            NullTerminatedString;
  1532.  
  1533.                                         NullTerminatedString = BlockToStringCopy(TotalString);
  1534.                                         if (NullTerminatedString != NIL)
  1535.                                             {
  1536.                                                 SetWindowName(Window->ScreenID,NullTerminatedString);
  1537.                                                 ChangeItemName(Window->MyMenuItem,NullTerminatedString);
  1538.                                                 ReleasePtr(NullTerminatedString);
  1539.                                             }
  1540.                                         ReleasePtr(TotalString);
  1541.                                     }
  1542.                                 ReleasePtr(LeftHalfOfString);
  1543.                             }
  1544.                         ReleasePtr(SeparatorString);
  1545.                     }
  1546.                 ReleasePtr(LocalNameCopy);
  1547.             }
  1548.     }
  1549.  
  1550.  
  1551. /* update the name in the title bar even if the document name hasn't changed. */
  1552. void                                AlgoSampWindowResetTitlebar(AlgoSampWindowRec* Window)
  1553.     {
  1554.         char*                            DocumentName;
  1555.  
  1556.         CheckPtrExistence(Window);
  1557.         DocumentName = GetCopyOfDocumentName(Window->MainWindow);
  1558.         if (DocumentName != NIL)
  1559.             {
  1560.                 AlgoSampWindowGlobalNameChange(Window,DocumentName);
  1561.                 ReleasePtr(DocumentName);
  1562.             }
  1563.     }
  1564.  
  1565.  
  1566. /* write back all modified data to the algosamp object */
  1567. MyBoolean                        AlgoSampWindowWritebackModifiedData(AlgoSampWindowRec* Window)
  1568.     {
  1569.         MyBoolean                    SuccessFlag = True;
  1570.  
  1571.         CheckPtrExistence(Window);
  1572.  
  1573.         if (TextEditDoesItNeedToBeSaved(Window->NameEdit))
  1574.             {
  1575.                 char*                        String;
  1576.  
  1577.                 String = AlgoSampWindowGetNameCopy(Window);
  1578.                 if (String != NIL)
  1579.                     {
  1580.                         AlgoSampObjectNewName(Window->AlgoSampObject,String);
  1581.                         TextEditHasBeenSaved(Window->NameEdit);
  1582.                     }
  1583.                  else
  1584.                     {
  1585.                         SuccessFlag = False;
  1586.                     }
  1587.             }
  1588.  
  1589.         if (TextEditDoesItNeedToBeSaved(Window->BodyEdit))
  1590.             {
  1591.                 char*                        String;
  1592.  
  1593.                 String = AlgoSampWindowGetFormulaCopy(Window);
  1594.                 if (String != NIL)
  1595.                     {
  1596.                         AlgoSampObjectNewFormula(Window->AlgoSampObject,String);
  1597.                         TextEditHasBeenSaved(Window->BodyEdit);
  1598.                     }
  1599.                  else
  1600.                     {
  1601.                         SuccessFlag = False;
  1602.                     }
  1603.             }
  1604.  
  1605.         if (TextEditDoesItNeedToBeSaved(Window->OriginEdit))
  1606.             {
  1607.                 AlgoSampObjectPutOrigin(Window->AlgoSampObject,
  1608.                     AlgoSampWindowGetOrigin(Window));
  1609.                 TextEditHasBeenSaved(Window->OriginEdit);
  1610.             }
  1611.  
  1612.         if (TextEditDoesItNeedToBeSaved(Window->SamplingRateEdit))
  1613.             {
  1614.                 AlgoSampObjectPutSamplingRate(Window->AlgoSampObject,
  1615.                     AlgoSampWindowGetSamplingRate(Window));
  1616.                 TextEditHasBeenSaved(Window->SamplingRateEdit);
  1617.             }
  1618.  
  1619.         if (TextEditDoesItNeedToBeSaved(Window->LoopStartEdit1))
  1620.             {
  1621.                 AlgoSampObjectPutLoopStart1(Window->AlgoSampObject,
  1622.                     AlgoSampWindowGetLoopStart1(Window));
  1623.                 TextEditHasBeenSaved(Window->LoopStartEdit1);
  1624.             }
  1625.  
  1626.         if (TextEditDoesItNeedToBeSaved(Window->LoopStartEdit2))
  1627.             {
  1628.                 AlgoSampObjectPutLoopStart2(Window->AlgoSampObject,
  1629.                     AlgoSampWindowGetLoopStart2(Window));
  1630.                 TextEditHasBeenSaved(Window->LoopStartEdit2);
  1631.             }
  1632.  
  1633.         if (TextEditDoesItNeedToBeSaved(Window->LoopStartEdit3))
  1634.             {
  1635.                 AlgoSampObjectPutLoopStart3(Window->AlgoSampObject,
  1636.                     AlgoSampWindowGetLoopStart3(Window));
  1637.                 TextEditHasBeenSaved(Window->LoopStartEdit3);
  1638.             }
  1639.  
  1640.         if (TextEditDoesItNeedToBeSaved(Window->LoopEndEdit1))
  1641.             {
  1642.                 AlgoSampObjectPutLoopEnd1(Window->AlgoSampObject,
  1643.                     AlgoSampWindowGetLoopEnd1(Window));
  1644.                 TextEditHasBeenSaved(Window->LoopEndEdit1);
  1645.             }
  1646.  
  1647.         if (TextEditDoesItNeedToBeSaved(Window->LoopEndEdit2))
  1648.             {
  1649.                 AlgoSampObjectPutLoopEnd2(Window->AlgoSampObject,
  1650.                     AlgoSampWindowGetLoopEnd2(Window));
  1651.                 TextEditHasBeenSaved(Window->LoopEndEdit2);
  1652.             }
  1653.  
  1654.         if (TextEditDoesItNeedToBeSaved(Window->LoopEndEdit3))
  1655.             {
  1656.                 AlgoSampObjectPutLoopEnd3(Window->AlgoSampObject,
  1657.                     AlgoSampWindowGetLoopEnd3(Window));
  1658.                 TextEditHasBeenSaved(Window->LoopEndEdit3);
  1659.             }
  1660.  
  1661.         if (TextEditDoesItNeedToBeSaved(Window->NaturalFrequencyEdit))
  1662.             {
  1663.                 AlgoSampObjectPutNaturalFrequency(Window->AlgoSampObject,
  1664.                     AlgoSampWindowGetNaturalFrequency(Window));
  1665.                 TextEditHasBeenSaved(Window->NaturalFrequencyEdit);
  1666.             }
  1667.  
  1668.         if (Window->ChannelsButtonChanged)
  1669.             {
  1670.                 AlgoSampObjectPutNumChannels(Window->AlgoSampObject,
  1671.                     AlgoSampWindowGetNumChannels(Window));
  1672.                 Window->ChannelsButtonChanged = False;
  1673.             }
  1674.  
  1675.         if (Window->BitsButtonChanged)
  1676.             {
  1677.                 AlgoSampObjectPutNumBits(Window->AlgoSampObject,
  1678.                     AlgoSampWindowGetNumBits(Window));
  1679.                 Window->BitsButtonChanged = False;
  1680.             }
  1681.  
  1682.         return SuccessFlag;
  1683.     }
  1684.